Computer Architecture for Plan Recognition

ABSTRACT

A computing machine receives a plurality of observations. The computing machine generates an observation data structure. The computing machine extends, in accordance with the causal structures and hierarchical relationships, the observation data structure to include predicted states or predicted actions that are not from the plurality of observations. The computing machine reduces, in accordance with consistency rules stored in a memory of the computing machine, the extended observation data structure. The computing machine provides an output associated with the reduced observation data structure.

PRIORITY CLAIM

This application claims priority to U.S. Provisional Pat. ApplicationNo. 63/341,157, filed on May 12, 2022, and titled “COMPUTER ARCHITECTUREFOR PLAN RECOGNITION,” the entirety of which is incorporated herein byreference.

TECHNICAL FIELD

Embodiments pertain to computer architecture. Some embodiments relate toartificial intelligence. Some embodiments relate to a computerarchitecture, system, and method for plan recognition.

BACKGROUND

Plan recognition may be useful in many different contexts, fromelectronic personal assistants to cyber security and control systems.Computer-implemented techniques for plan recognition may be desirable.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates the training and use of a machine-learning program,in accordance with some embodiments.

FIG. 2 illustrates an example neural network, in accordance with someembodiments.

FIG. 3 illustrates the training of an image recognition machine learningprogram, in accordance with some embodiments.

FIG. 4 illustrates the feature-extraction process and classifiertraining, in accordance with some embodiments.

FIG. 5 is a block diagram of a computing machine, in accordance withsome embodiments.

FIG. 6 is a block diagram of an example of a system for planrecognition, in accordance with some embodiments.

FIG. 7 is a flow chart of an example of a method for plan recognition,in accordance with some embodiments.

FIG. 8 illustrates example data structures which may be used for planrecognition, in accordance with some embodiments.

FIG. 9 is a block diagram of an example of a plan recognition system, inaccordance with some embodiments.

FIGS. 10A-10B illustrate examples of data representing a plan, inaccordance with some embodiments.

FIG. 11 is a flow chart of an example of a plan recognition method, inaccordance with some embodiments.

DETAILED DESCRIPTION

The following description and the drawings sufficiently illustratespecific embodiments to enable those skilled in the art to practicethem. Other embodiments may incorporate structural, logical, electrical,process, and other changes. Portions and features of some embodimentsmay be included in, or substituted for, those of other embodiments.Embodiments set forth in the claims encompass all available equivalentsof those claims.

Aspects of the present technology may be implemented as part of acomputer system. The computer system may be one physical machine, or maybe distributed among multiple physical machines, such as by role orfunction, or by process thread in the case of a cloud computingdistributed model. In various embodiments, aspects of the technology maybe configured to run in virtual machines that in turn are executed onone or more physical machines. It will be understood by persons of skillin the art that features of the technology may be realized by a varietyof different suitable machine implementations.

The system includes various engines, each of which is constructed,programmed, configured, or otherwise adapted, to carry out a function orset of functions. The term engine as used herein means a tangibledevice, component, or arrangement of components implemented usinghardware, such as by an application specific integrated circuit (ASIC)or field-programmable gate array (FPGA), for example, or as acombination of hardware and software, such as by a processor-basedcomputing platform and a set of program instructions that transform thecomputing platform into a special-purpose device to implement theparticular functionality. An engine may also be implemented as acombination of the two, with certain functions facilitated by hardwarealone, and other functions facilitated by a combination of hardware andsoftware.

In an example, the software may reside in executable or non-executableform on a tangible machine-readable storage medium. Software residing innon-executable form may be compiled, translated, or otherwise convertedto an executable form prior to, or during, runtime. In an example, thesoftware, when executed by the underlying hardware of the engine, causesthe hardware to perform the specified operations. Accordingly, an engineis physically constructed, or specifically configured (e.g., hardwired),or temporarily configured (e.g., programmed) to operate in a specifiedmanner or to perform part or all of any operations described herein inconnection with that engine.

Considering examples in which engines are temporarily configured, eachof the engines may be instantiated at different moments in time. Forexample, where the engines comprise a general-purpose hardware processorcore configured using software, the general-purpose hardware processorcore may be configured as respective different engines at differenttimes. Software may accordingly configure a hardware processor core, forexample, to constitute a particular engine at one instance of time andto constitute a different engine at a different instance of time.

In certain implementations, at least a portion, and in some cases, all,of an engine may be executed on the processor(s) of one or morecomputers that execute an operating system, system programs, andapplication programs, while also implementing the engine usingmultitasking, multithreading, distributed (e.g., cluster, peer-peer,cloud, etc.) processing where appropriate, or other such techniques.Accordingly, each engine may be realized in a variety of suitableconfigurations, and should generally not be limited to any particularimplementation exemplified herein, unless such limitations are expresslycalled out.

In addition, an engine may itself be composed of more than onesub-engines, each of which may be regarded as an engine in its ownright. Moreover, in the embodiments described herein, each of thevarious engines corresponds to a defined functionality; however, itshould be understood that in other contemplated embodiments, eachfunctionality may be distributed to more than one engine. Likewise, inother contemplated embodiments, multiple defined functionalities may beimplemented by a single engine that performs those multiple functions,possibly alongside other functions, or distributed differently among aset of engines than specifically illustrated in the examples herein.

As used herein, the term “model” encompasses its plain and ordinarymeaning. A model may include, among other things, one or more engineswhich receive an input and compute an output based on the input. Theoutput may be a classification. For example, an image file may beclassified as depicting a cat or not depicting a cat. Alternatively, theimage file may be assigned a numeric score indicating a likelihoodwhether the image file depicts the cat, and image files with a scoreexceeding a threshold (e.g., 0.9 or 0.95) may be determined to depictthe cat.

This document may reference a specific number of things (e.g., “sixmobile devices”). Unless explicitly set forth otherwise, the numbersprovided are examples only and may be replaced with any positiveinteger, integer or real number, as would make sense for a givensituation. For example, “six mobile devices” may, in alternativeembodiments, include any positive integer number of mobile devices.Unless otherwise mentioned, an object referred to in singular form(e.g., “a computer” or “the computer”) may include one or multipleobjects (e.g., “the computer” may refer to one or multiple computers).

FIG. 1 illustrates the training and use of a machine-learning program,according to some example embodiments. In some example embodiments,machine-learning programs (MLPs), also referred to as machine-learningalgorithms or tools, are utilized to perform operations associated withmachine learning tasks, such as image recognition or machinetranslation.

Machine learning is a field of study that gives computers the ability tolearn without being explicitly programmed. Machine learning explores thestudy and construction of algorithms, also referred to herein as tools,which may learn from existing data and make predictions about new data.Such machine-learning tools operate by building a model from exampletraining data 112 in order to make data-driven predictions or decisionsexpressed as outputs or assessments 120. Although example embodimentsare presented with respect to a few machine-learning tools, theprinciples presented herein may be applied to other machine-learningtools.

In some example embodiments, different machine-learning tools may beused. For example, Logistic Regression (LR), Naive-Bayes, Random Forest(RF), neural networks (NN), matrix factorization, and Support VectorMachines (SVM) tools may be used for classifying or scoring jobpostings.

Two common types of problems in machine learning are classificationproblems and regression problems. Classification problems, also referredto as categorization problems, aim at classifying items into one ofseveral category values (for example, is this object an apple or anorange). Regression algorithms aim at quantifying some items (forexample, by providing a value that is a real number). Themachine-learning algorithms utilize the training data 112 to findcorrelations among identified features 102 that affect the outcome.

The machine-learning algorithms utilize features 102 for analyzing thedata to generate assessments 120. A feature 102 is an individualmeasurable property of a phenomenon being observed. The concept of afeature is related to that of an explanatory variable used instatistical techniques such as linear regression. Choosing informative,discriminating, and independent features is important for effectiveoperation of the MLP in pattern recognition, classification, andregression. Features may be of different types, such as numericfeatures, strings, and graphs.

In one example embodiment, the features 102 may be of different typesand may include one or more of words of the message 103, messageconcepts 104, communication history 105, past user behavior 106, subjectof the message 107, other message attributes 108, sender 109, and userdata 110.

The machine-learning algorithms utilize the training data 112 to findcorrelations among the identified features 102 that affect the outcomeor assessment 120. In some example embodiments, the training data 112includes labeled data, which is known data for one or more identifiedfeatures 102 and one or more outcomes, such as detecting communicationpatterns, detecting the meaning of the message, generating a summary ofthe message, detecting action items in the message, detecting urgency inthe message, detecting a relationship of the user to the sender,calculating score attributes, calculating message scores, etc.

With the training data 112 and the identified features 102, themachine-learning tool is trained at operation 114. The machine-learningtool appraises the value of the features 102 as they correlate to thetraining data 112. The result of the training is the trainedmachine-learning program 116.

When the machine-learning program 116 is used to perform an assessment,new data 118 is provided as an input to the trained machine-learningprogram 116, and the machine-learning program 116 generates theassessment 120 as output. For example, when a message is checked for anaction item, the machine-learning program utilizes the message contentand message metadata to determine if there is a request for an action inthe message.

Machine learning techniques train models to accurately make predictionson data fed into the models (e.g., what was said by a user in a givenutterance; whether a noun is a person, place, or thing; what the weatherwill be like tomorrow). During a learning phase, the models aredeveloped against a training dataset of inputs to optimize the models tocorrectly predict the output for a given input. Generally, the learningphase may be supervised, semi-supervised, or unsupervised; indicating adecreasing level to which the “correct” outputs are provided incorrespondence to the training inputs. In a supervised learning phase,all of the outputs are provided to the model and the model is directedto develop a general rule or algorithm that maps the input to theoutput. In contrast, in an unsupervised learning phase, the desiredoutput is not provided for the inputs so that the model may develop itsown rules to discover relationships within the training dataset. In asemi-supervised learning phase, an incompletely labeled training set isprovided, with some of the outputs known and some unknown for thetraining dataset.

Models may be run against a training dataset for several epochs (e.g.,iterations), in which the training dataset is repeatedly fed into themodel to refine its results. For example, in a supervised learningphase, a model is developed to predict the output for a given set ofinputs, and is evaluated over several epochs to more reliably providethe output that is specified as corresponding to the given input for thegreatest number of inputs for the training dataset. In another example,for an unsupervised learning phase, a model is developed to cluster thedataset into n groups, and is evaluated over several epochs as to howconsistently it places a given input into a given group and how reliablyit produces the n desired clusters across each epoch.

Once an epoch is run, the models are evaluated and the values of theirvariables are adjusted to attempt to better refine the model in aniterative fashion. In various aspects, the evaluations are biasedagainst false negatives, biased against false positives, or evenlybiased with respect to the overall accuracy of the model. The values maybe adjusted in several ways depending on the machine learning techniqueused. For example, in a genetic or evolutionary algorithm, the valuesfor the models that are most successful in predicting the desiredoutputs are used to develop values for models to use during thesubsequent epoch, which may include random variation/mutation to provideadditional data points. One of ordinary skill in the art will befamiliar with several other machine learning algorithms that may beapplied with the present disclosure, including linear regression, randomforests, decision tree learning, neural networks, deep neural networks,etc.

Each model develops a rule or algorithm over several epochs by varyingthe values of one or more variables affecting the inputs to more closelymap to a desired result, but as the training dataset may be varied, andis preferably very large, perfect accuracy and precision may not beachievable. A number of epochs that make up a learning phase, therefore,may be set as a given number of trials or a fixed time/computing budget,or may be terminated before that number/budget is reached when theaccuracy of a given model is high enough or low enough or an accuracyplateau has been reached. For example, if the training phase is designedto run n epochs and produce a model with at least 95% accuracy, and sucha model is produced before the n^(th) epoch, the learning phase may endearly and use the produced model satisfying the end-goal accuracythreshold. Similarly, if a given model is inaccurate enough to satisfy arandom chance threshold (e.g., the model is only 55% accurate indetermining true/false outputs for given inputs), the learning phase forthat model may be terminated early, although other models in thelearning phase may continue training. Similarly, when a given modelcontinues to provide similar accuracy or vacillate in its results acrossmultiple epochs - having reached a performance plateau - the learningphase for the given model may terminate before the epochnumber/computing budget is reached.

Once the learning phase is complete, the models are finalized. In someexample embodiments, models that are finalized are evaluated againsttesting criteria. In a first example, a testing dataset that includesknown outputs for its inputs is fed into the finalized models todetermine an accuracy of the model in handling data that it has not beentrained on. In a second example, a false positive rate or false negativerate may be used to evaluate the models after finalization. In a thirdexample, a delineation between data clusterings is used to select amodel that produces the clearest bounds for its clusters of data.

FIG. 2 illustrates an example neural network 204, in accordance withsome embodiments. As shown, the neural network 204 receives, as input,source domain data 202. The input is passed through a plurality oflayers 206 to arrive at an output. Each layer 206 includes multipleneurons 208. The neurons 208 receive input from neurons of a previouslayer and apply weights to the values received from those neurons inorder to generate a neuron output. The neuron outputs from the finallayer 206 are combined to generate the output of the neural network 204.

As illustrated at the bottom of FIG. 2 , the input is a vector x. Theinput is passed through multiple layers 206, where weights W₁, W₂,...,W_(i) are applied to the input to each layer to arrive at ƒ¹(x), ƒ²(x),...,ƒ⁻¹(x), until finally the output ƒ(x) is computed.

In some example embodiments, the neural network 204 (e.g., deeplearning, deep convolutional, or recurrent neural network) comprises aseries of neurons 208, such as Long Short Term Memory (LSTM) nodes,arranged into a network. A neuron 208 is an architectural element usedin data processing and artificial intelligence, particularly machinelearning, which includes memory that may determine when to “remember”and when to “forget” values held in that memory based on the weights ofinputs provided to the given neuron 208. Each of the neurons 208 usedherein are configured to accept a predefined number of inputs from otherneurons 208 in the neural network 204 to provide relational andsub-relational outputs for the content of the frames being analyzed.Individual neurons 208 may be chained together and/or organized intotree structures in various configurations of neural networks to provideinteractions and relationship learning modeling for how each of theframes in an utterance are related to one another.

For example, an LSTM node serving as a neuron includes several gates tohandle input vectors (e.g., phonemes from an utterance), a memory cell,and an output vector (e.g., contextual representation). The input gateand output gate control the information flowing into and out of thememory cell, respectively, whereas forget gates optionally removeinformation from the memory cell based on the inputs from linked cellsearlier in the neural network. Weights and bias vectors for the variousgates are adjusted over the course of a training phase, and once thetraining phase is complete, those weights and biases are finalized fornormal operation. One of skill in the art will appreciate that neuronsand neural networks may be constructed programmatically (e.g., viasoftware instructions) or via specialized hardware linking each neuronto form the neural network.

Neural networks utilize features for analyzing the data to generateassessments (e.g., recognize units of speech). A feature is anindividual measurable property of a phenomenon being observed. Theconcept of feature is related to that of an explanatory variable used instatistical techniques such as linear regression. Further, deep featuresrepresent the output of nodes in hidden layers of the deep neuralnetwork.

A neural network, sometimes referred to as an artificial neural network,is a computing system/apparatus based on consideration of biologicalneural networks of animal brains. Such systems/apparatus progressivelyimprove performance, which is referred to as learning, to perform tasks,typically without task-specific programming. For example, in imagerecognition, a neural network may be taught to identify images thatcontain an object by analyzing example images that have been tagged witha name for the object and, having learnt the object and name, may usethe analytic results to identify the object in untagged images. A neuralnetwork is based on a collection of connected units called neurons,where each connection, called a synapse, between neurons can transmit aunidirectional signal with an activating strength that varies with thestrength of the connection. The receiving neuron can activate andpropagate a signal to downstream neurons connected to it, typicallybased on whether the combined incoming signals, which are frompotentially many transmitting neurons, are of sufficient strength, wherestrength is a parameter.

A deep neural network (DNN) is a stacked neural network, which iscomposed of multiple layers. The layers are composed of nodes, which arelocations where computation occurs, loosely patterned on a neuron in thehuman brain, which fires when it encounters sufficient stimuli. A nodecombines input from the data with a set of coefficients, or weights,that either amplify or dampen that input, which assigns significance toinputs for the task the algorithm is trying to learn. These input-weightproducts are summed, and the sum is passed through what is called anode’s activation function, to determine whether and to what extent thatsignal progresses further through the network to affect the ultimateoutcome. A DNN uses a cascade of many layers of non-linear processingunits for feature extraction and transformation. Each successive layeruses the output from the previous layer as input. Higher-level featuresare derived from lower-level features to form a hierarchicalrepresentation. The layers following the input layer may be convolutionlayers that produce feature maps that are filtering results of theinputs and are used by the next convolution layer.

In training of a DNN architecture, a regression, which is structured asa set of statistical processes for estimating the relationships amongvariables, can include a minimization of a cost function. The costfunction may be implemented as a function to return a numberrepresenting how well the neural network performed in mapping trainingexamples to correct output. In training, if the cost function value isnot within a pre-determined range, based on the known training images,backpropagation is used, where backpropagation is a common method oftraining artificial neural networks that are used with an optimizationmethod such as a stochastic gradient descent (SGD) method.

Use of backpropagation can include propagation and weight update. Whenan input is presented to the neural network, it is propagated forwardthrough the neural network, layer by layer, until it reaches the outputlayer. The output of the neural network is then compared to the desiredoutput, using the cost function, and an error value is calculated foreach of the nodes in the output layer. The error values are propagatedbackwards, starting from the output, until each node has an associatederror value which roughly represents its contribution to the originaloutput. Backpropagation can use these error values to calculate thegradient of the cost function with respect to the weights in the neuralnetwork. The calculated gradient is fed to the selected optimizationmethod to update the weights to attempt to minimize the cost function.

FIG. 3 illustrates the training of an image recognition machine learningprogram, in accordance with some embodiments. The machine learningprogram may be implemented at one or more computing machines. Block 302illustrates a training set, which includes multiple classes 304. Eachclass 304 includes multiple images 306 associated with the class. Eachclass 304 may correspond to a type of object in the image 306 (e.g., adigit 0-9, a man or a woman, a cat or a dog, etc.). In one example, themachine learning program is trained to recognize images of thepresidents of the United States, and each class corresponds to eachpresident (e.g., one class corresponds to Barack Obama, one classcorresponds to George W. Bush, one class corresponds to Bill Clinton,etc.). At block 308 the machine learning program is trained, forexample, using a deep neural network. At block 310, the trainedclassifier, generated by the training of block 308, recognizes an image312, and at block 314 the image is recognized. For example, if the image312 is a photograph of Bill Clinton, the classifier recognizes the imageas corresponding to Bill Clinton at block 314.

FIG. 3 illustrates the training of a classifier, according to someexample embodiments. A machine learning algorithm is designed forrecognizing faces, and a training set 302 includes data that maps asample to a class 304 (e.g., a class includes all the images of purses).The classes may also be referred to as labels. Although embodimentspresented herein are presented with reference to object recognition, thesame principles may be applied to train machine-learning programs usedfor recognizing any type of items.

The training set 302 includes a plurality of images 306 for each class304 (e.g., image 306), and each image is associated with one of thecategories to be recognized (e.g., a class). The machine learningprogram is trained 308 with the training data to generate a classifier310 operable to recognize images. In some example embodiments, themachine learning program is a DNN.

When an input image 312 is to be recognized, the classifier 310 analyzesthe input image 312 to identify the class (e.g., class 314)corresponding to the input image 312.

FIG. 4 illustrates the feature-extraction process and classifiertraining, according to some example embodiments. Training the classifiermay be divided into feature extraction layers 402 and classifier layer414. Each image is analyzed in sequence by a plurality of layers 406-413in the feature-extraction layers 402.

With the development of deep convolutional neural networks, the focus inface recognition has been to learn a good face feature space, in whichfaces of the same person are close to each other, and faces of differentpersons are far away from each other. For example, the verification taskwith the LFW (Labeled Faces in the Wild) dataset has been often used forface verification.

Many face identification tasks (e.g., MegaFace and LFW) are based on asimilarity comparison between the images in the gallery set and thequery set, which is essentially a K-nearest-neighborhood (KNN) method toestimate the person’s identity. In the ideal case, there is a good facefeature extractor (inter-class distance is always larger than theintra-class distance), and the KNN method is adequate to estimate theperson’s identity.

Feature extraction is a process to reduce the amount of resourcesrequired to describe a large set of data. When performing analysis ofcomplex data, one of the major problems stems from the number ofvariables involved. Analysis with a large number of variables generallyrequires a large amount of memory and computational power, and it maycause a classification algorithm to overfit to training samples andgeneralize poorly to new samples. Feature extraction is a general termdescribing methods of constructing combinations of variables to getaround these large data-set problems while still describing the datawith sufficient accuracy for the desired purpose.

In some example embodiments, feature extraction starts from an initialset of measured data and builds derived values (features) intended to beinformative and non-redundant, facilitating the subsequent learning andgeneralization steps. Further, feature extraction is related todimensionality reduction, such as reducing large vectors (sometimes withvery sparse data) to smaller vectors capturing the same, or similar,amount of information.

Determining a subset of the initial features is called featureselection. The selected features are expected to contain the relevantinformation from the input data, so that the desired task can beperformed by using this reduced representation instead of the completeinitial data. DNN utilizes a stack of layers, where each layer performsa function. For example, the layer could be a convolution, a non-lineartransform, the calculation of an average, etc. Eventually this DNNproduces outputs by classifier 414. In FIG. 4 , the data travels fromleft to right and the features are extracted. The goal of training theneural network is to find the parameters of all the layers that makethem adequate for the desired task.

As shown in FIG. 4 , a “stride of 4” filter is applied at layer 406, andmax pooling is applied at layers 407-413. The stride controls how thefilter convolves around the input volume. “Stride of 4” refers to thefilter convolving around the input volume four units at a time. Maxpooling refers to down-sampling by selecting the maximum value in eachmax pooled region.

In some example embodiments, the structure of each layer is predefined.For example, a convolution layer may contain small convolution kernelsand their respective convolution parameters, and a summation layer maycalculate the sum, or the weighted sum, of two pixels of the inputimage. Training assists in defining the weight coefficients for thesummation.

One way to improve the performance of DNNs is to identify newerstructures for the feature-extraction layers, and another way is byimproving the way the parameters are identified at the different layersfor accomplishing a desired task. The challenge is that for a typicalneural network, there may be millions of parameters to be optimized.Trying to optimize all these parameters from scratch may take hours,days, or even weeks, depending on the amount of computing resourcesavailable and the amount of data in the training set.

FIG. 5 illustrates a circuit block diagram of a computing machine 500 inaccordance with some embodiments. In some embodiments, components of thecomputing machine 500 may store or be integrated into other componentsshown in the circuit block diagram of FIG. 5 . For example, portions ofthe computing machine 500 may reside in the processor 502 and may bereferred to as “processing circuitry.” Processing circuitry may includeprocessing hardware, for example, one or more central processing units(CPUs), one or more graphics processing units (GPUs), and the like. Inalternative embodiments, the computing machine 500 may operate as astandalone device or may be connected (e.g., networked) to othercomputers. In a networked deployment, the computing machine 500 mayoperate in the capacity of a server, a client, or both in server-clientnetwork environments. In an example, the computing machine 500 may actas a peer machine in peer-to-peer (P2P) (or other distributed) networkenvironment. In this document, the phrases P2P, device-to-device (D2D)and sidelink may be used interchangeably. The computing machine 500 maybe a specialized computer, a personal computer (PC), a tablet PC, apersonal digital assistant (PDA), a mobile telephone, a smart phone, aweb appliance, a network router, switch or bridge, or any machinecapable of executing instructions (sequential or otherwise) that specifyactions to be taken by that machine.

Examples, as described herein, may include, or may operate on, logic ora number of components, modules, or mechanisms. Modules and componentsare tangible entities (e.g., hardware) capable of performing specifiedoperations and may be configured or arranged in a certain manner. In anexample, circuits may be arranged (e.g., internally or with respect toexternal entities such as other circuits) in a specified manner as amodule. In an example, the whole or part of one or more computersystems/apparatus (e.g., a standalone, client or server computer system)or one or more hardware processors may be configured by firmware orsoftware (e.g., instructions, an application portion, or an application)as a module that operates to perform specified operations. In anexample, the software may reside on a machine readable medium. In anexample, the software, when executed by the underlying hardware of themodule, causes the hardware to perform the specified operations.

Accordingly, the term “module” (and “component”) is understood toencompass a tangible entity, be that an entity that is physicallyconstructed, specifically configured (e.g., hardwired), or temporarily(e.g., transitorily) configured (e.g., programmed) to operate in aspecified manner or to perform part or all of any operation describedherein. Considering examples in which modules are temporarilyconfigured, each of the modules need not be instantiated at any onemoment in time. For example, where the modules comprise ageneral-purpose hardware processor configured using software, thegeneral-purpose hardware processor may be configured as respectivedifferent modules at different times. Software may accordingly configurea hardware processor, for example, to constitute a particular module atone instance of time and to constitute a different module at a differentinstance of time.

The computing machine 500 may include a hardware processor 502 (e.g., acentral processing unit (CPU), a GPU, a hardware processor core, or anycombination thereof), a main memory 504 and a static memory 506, some orall of which may communicate with each other via an interlink (e.g.,bus) 508. Although not shown, the main memory 504 may contain any or allof removable storage and non-removable storage, volatile memory ornon-volatile memory. The computing machine 500 may further include avideo display unit 510 (or other display unit), an alphanumeric inputdevice 512 (e.g., a keyboard), and a user interface (UI) navigationdevice 514 (e.g., a mouse). In an example, the display unit 510, inputdevice 512 and UI navigation device 514 may be a touch screen display.The computing machine 500 may additionally include a storage device(e.g., drive unit) 516, a signal generation device 518 (e.g., aspeaker), a network interface device 520, and one or more sensors 521,such as a global positioning system (GPS) sensor, compass,accelerometer, or other sensor. The computing machine 500 may include anoutput controller 528, such as a serial (e.g., universal serial bus(USB), parallel, or other wired or wireless (e.g., infrared (IR), nearfield communication (NFC), etc.) connection to communicate or controlone or more peripheral devices (e.g., a printer, card reader, etc.).

The drive unit 516 (e.g., a storage device) may include a machinereadable medium 522 on which is stored one or more sets of datastructures or instructions 524 (e.g., software) embodying or utilized byany one or more of the techniques or functions described herein. Theinstructions 524 may also reside, completely or at least partially,within the main memory 504, within static memory 506, or within thehardware processor 502 during execution thereof by the computing machine500. In an example, one or any combination of the hardware processor502, the main memory 504, the static memory 506, or the storage device516 may constitute machine readable media.

While the machine readable medium 522 is illustrated as a single medium,the term “machine readable medium” may include a single medium ormultiple media (e.g., a centralized or distributed database, and/orassociated caches and servers) configured to store the one or moreinstructions 524.

The term “machine readable medium” may include any medium that iscapable of storing, encoding, or carrying instructions for execution bythe computing machine 500 and that cause the computing machine 500 toperform any one or more of the techniques of the present disclosure, orthat is capable of storing, encoding or carrying data structures used byor associated with such instructions. Non-limiting machine readablemedium examples may include solid-state memories, and optical andmagnetic media. Specific examples of machine readable media may include:non-volatile memory, such as semiconductor memory devices (e.g.,Electrically Programmable Read-Only Memory (EPROM), ElectricallyErasable Programmable Read-Only Memory (EEPROM)) and flash memorydevices; magnetic disks, such as internal hard disks and removabledisks; magneto-optical disks; Random Access Memory (RAM); and CD-ROM andDVD-ROM disks. In some examples, machine readable media may includenon-transitory machine readable media. In some examples, machinereadable media may include machine readable media that is not atransitory propagating signal.

The instructions 524 may further be transmitted or received over acommunications network 526 using a transmission medium via the networkinterface device 520 utilizing any one of a number of transfer protocols(e.g., frame relay, internet protocol (IP), transmission controlprotocol (TCP), user datagram protocol (UDP), hypertext transferprotocol (HTTP), etc.). Example communication networks may include alocal area network (LAN), a wide area network (WAN), a packet datanetwork (e.g., the Internet), mobile telephone networks (e.g., cellularnetworks), Plain Old Telephone (POTS) networks, and wireless datanetworks (e.g., Institute of Electrical and Electronics Engineers (IEEE)802.11 family of standards known as Wi-Fi®, IEEE 802.16 family ofstandards known as WiMax®), IEEE 802.15.4 family of standards, a LongTerm Evolution (LTE) family of standards, a Universal MobileTelecommunications System (UMTS) family of standards, peer-to-peer (P2P)networks, among others. In an example, the network interface device 520may include one or more physical jacks (e.g., Ethernet, coaxial, orphone jacks) or one or more antennas to connect to the communicationsnetwork 526.

FIG. 6 is a block diagram of an example of a system 600 for planrecognition, in accordance with some embodiments. As shown in FIG. 6 ,observations 602 are accessed by a computing machine 604, and thecomputing machine 604 generates a prediction 606 based on theobservation 602. To generate the prediction 606, the computing machine604 accesses a data repository 608 that stores sets of actions 610A,610B, and 610C.

The computing machine 604 may include some or all of the components ofthe computing machine 500. The computing machine 604 may be at least oneof a server, a client device, a laptop computer, a desktop computer, amobile phone, a tablet computer, or the like. The data repository 608may be a database or any other data storage unit.

The computing machine 604 receives the observations 602, which mayinclude action or state change observations. The computing machine 604accesses the data repository 608. The data repository 608 stores datastructures representing actions 610A, 610B, 610C and their effects onthe world, possible goals and plans or rules about how plans can beconstructed to achieve the goals. While three data structures of actions610A, 610B, 610C are illustrated, the data repository 608 may includeother numbers of data structures of actions, with each data structureincluding various numbers of actions. As used herein, an action mayinclude, among other things, a first order logical representation of anact, including the name of the act type and the names of any parametersof the act. Examples of actions include graspA( lefthand, box23 ),liftA( lefthand ), openA( lefthand, door23 ), or the like. An agent maybe, among other things, an actor in the world (e.g., who performs anaction). An actor may include one or more humans, one or more vehicles,one or more systems, a system including multiple subsystems, or thelike. As used herein, a goal may include a first order predicate orconjunction of first order predicates that identify at least one stateof the world that can be the objective of some agent. For example,inRoomP( block7, room23 ) captures the goal that some agent wishedblock7 to be in room23. Some implementations support the presence oftyped variables in their goal specification. For example, inRoomP(block7, X:room) denotes the goal that block7 is in some room that islikely to be bound at a later time in the plan. As used herein, a statemay include a first order conjunction of ground predicates intended tocapture a state of the world. Each such ground predicate has a predicatename and can have parameters that provide the predicate’s grounding. Forexample, onP( block1, block23 ), inhandP( lefthand, block25 ), openP(door23 ), rainingP(), or the like.

In processing the received observations 602, the computing machine 604identifies a set of plan prefixes corresponding to the plurality ofaction and state change observations 602 by mapping the plurality ofaction and state change observations 602 to data structures representingsets of actions (e.g., one or more of the data structures representingsets of actions 610A, 610B, 610C). An example of mapping observations602 to one of the data structures representing sets of actions 610A,610B, 610C is described in conjunction with FIG. 8 . Some of the planprefixes in the set of plan prefixes may include data that capturesfuture subgoals of a plan. The future subgoals may lack evidencesupporting themselves in the received observations 602.

As used herein, a plan may include a sequence of actions which isexecuted in order achieve a goal. In some implementations, a plan isrepresented as a sequence of action observations connected by theirassociated causal structures and hierarchical relationships. As usedherein, the phrase “plan prefix” encompasses its plain and ordinarymeaning. A plan prefix may include a part of a plan. For example, agrocery shopping plan may include the actions: (1) drive to supermarket,(2) place groceries in shopping cart, (3) pay for groceries, and (4)drive home. A plan prefix of this plan may include (1) drive tosupermarket, and (2) place groceries in shopping cart, but not (3) payfor groceries, and (4) drive home. In one use case, a computing machinemay observe a person named Alex (1) drive to supermarket, and (2) placegroceries in shopping cart. Based on these observation, the computingmachine may assume that Alex has the future subgoals of (3) pay forgroceries, and (4) drive home. The future subgoals may lack evidence forthemselves in the prior observations of Alex. In some cases, thepredictions of the computing machine may be incorrect, as Alex’sactivities may be consistent with other plans (which may or may not berepresented in the sets of actions 610A, 610B, 610C stored in the datarepository 608). For example, the observations of Alex (1) driving tosupermarket and (2) placing groceries in shopping cart may be consistentwith Alex being an employee of the supermarket who assists customerswith curbside pick-up, in which case Alex would not (3) pay forgroceries, but would (4) drive home after his shift is over.Alternatively, Alex may be a customer at the supermarket and may (3) payfor groceries, but might drive to another destination (e.g., Alex’sworkplace or a restaurant) after paying for the groceries, in which caseAlex would not (4) drive home (at least until after Alex departs fromthe other destination). In another alternative, Alex may put back thegroceries in the shopping cart and may be picked up from the grocerystore by a friend, while Alex’s spouse later obtains Alex’s car from thegrocery store parking lot, in which case Alex would neither (3) pay forgroceries nor (4) drive home.

In another example use case, a computing machine observes (e.g., via acamera coupled to the computing machine) a person named Ben pick up apot, fill the pot with water, and pull a box of pasta off the kitchenshelf. Based on these observations, the computing machine may determine,with a high degree of certainty, that Ben is making some kind of pastadish. The plan recognizer executing on the computing machine may havemultiple different hypotheses about what kind of sauce Ben are makingfor the pasta or whether Ben is making sauce at all. In at least one ofthe hypotheses, the plan recognizer may consider that Ben was going tomake marinara sauce. To do this, the plan recognizer would have a nodein the data structure that would capture the future sub-goal for makingmarinara sauce. This sub-goal might initially lack evidence supportingitself, and might correspond to the blocks 1002b, 1004b shown in FIG.10B. In other words, the plan to make marinara sauce would not bedirectly supported by any of the observations (i.e., the computingmachine has only seen indirect evidence for this future sub-goal). Thecomputing machine has not observed Ben pull out a jar of sauce, or theingredients for making the sauce, or any of the other sub-steps of aplan for making the sauce). As illustrated in FIG. 10B and described ingreater detail below, the planner would create hypothetical plans forthe making of the marinara sauce and add them to the data structure.

The computing machine 604 computes a prediction of the complete planexecution from each plan prefix by searching through the plurality ofdata structures representing actions 610A, 610B, 610C to find at leastone completion of the plan, filling in details for each of theunsupported future subgoals of the plan that can be inferred to productthe goal of the plan, and marking the plan completion as a prediction ofthe rest of the execution of the plan.

In some implementations, the data structures representing actions 610A,610B, 610C represent plans, and the data structures are tree structureswith leaf nodes and root nodes. The root node identifies the entire plan(e.g., “grocery shopping,” as described above). The leaf nodes includeindividual actions of the plan (e.g., (1) drive to supermarket, (2)place groceries in shopping cart, (3) pay for groceries, and (4) drivehome, as described above). An example of a tree data structurerepresenting a plan is described in conjunction with FIG. 8 .

The computing machine 604 generates the prediction 606, using the datastructures representing actions 610A, 610B, 610C, a complete sequence offuture actions (and implied states) that complete the plan(s) associatedwith the plan prefix(es) identified from the observations 602. Thecomputing machine 604 provides outputs associated with the prediction606. The outputs may include all or a portion of the current inferredand future predicted plans. The outputs may include visual or audiooutputs provided via a display device or a speaker. The outputs mayinclude data transmitted over a network or over a direct wired orwireless connection.

FIG. 7 is a flow chart of an example of a method 700 for planrecognition, in accordance with some embodiments. As described below,the method 700 is performed by the computing machine 604. However, inalternative implementations, the method 700 may be performed by othermachines, for example, a machine including all or a portion of thecomponents of the computing machine 500.

At block 702, the computing machine 604 receives a plurality ofobservations 602. The observations 602 may be received from sensor(s) inreal-time. The sensor(s) may include any sensors, such as a camera(visual spectrum, infrared, or ultraviolet light sensor), a microphone(audio sensor), a temperature sensor, a pressure sensor, a chemicalsensor, or the like. Alternatively, the observations 602 may be obtainedfrom a data storage unit or manually entered into the computing machine604 by a user.

As used herein, the term “real-time” may include, among other things,the output being provided without any intentional delays after the inputis received. There may still be some unintentional delays, for example,due to the processing speed or the network connection speed of thecomputing machine and/or other processes executing on the computingmachine in parallel with the technique described herein.

At block 704, the computing machine 604 accesses a data repository 608storing a plurality of data structures representing actions 610A, 610B,610C. The data structures representing actions 610A, 610B, 610C mayrepresent actions in action-outcome relationships or goal-orientedactivities. In some examples, the plurality of data structuresrepresenting actions 610A, 610B, 610C comprise tree data structures.Each tree data structure has a root node representing a goal of a planand leaf nodes representing the actions associated with the plan. Insome examples, a data structure (from among the data structures in thedata repository) stores an ordered set of actions. The ordered set ofactions represents multiple actions to cause an outcome or multipleactions of a goal-oriented activity. For example, an ordered set ofactions in an action set for taking may be: (1) reach, (2) grasp, and(3) lift. An ordered set of actions in an action set for groceryshopping may be: (1) drive to supermarket, (2) place groceries inshopping cart, (3) pay for groceries, and (4) drive home.

At block 706, the computing machine 604 identifies, by mapping at leasta portion of the plurality of observations 602 onto at least a part ofone or more of the plurality of data structures representing actions610A, 610B, 610C, a plan prefix associated with the plurality ofobservations 602. The plan prefix includes a future subgoal and a set ofactions. In some examples, the plan prefix is mapped to a timeline. Thetimeline indicates predicted states based on a plan associated with theplan prefix. A predicted state may include a state added to anobservation data structure by the planning process. The predicted statemay correspond to the result of the execution of predicted actions atsome time in the future. The predicted state may be a part of a plan tocomplete one of the plans inferred by the plan recognizer. A predictedaction may include an action added to an observation data structure bythe planning process. The predicted action may be executed at some timein the future as part of a plan to complete one of the plans inferred bythe plan recognizer.

At block 708, the computing machine 604 generates a prediction 606 basedon the plan prefix. The prediction 606 includes a future action or afuture outcome. The prediction 606 may be generated based on physicsdata, traffic data, or capability data. The physics data may includerepresentations of the laws of physics. The traffic data may includereal-time traffic data obtained by sensors, average or predicted trafficdata obtained based on traffic patterns. For example, traffic on ahighway going into a city center at 8:00 AM on a weekday morning islikely to be similar to traffic on that highway at 8:00 AM on otherweekday mornings.

At block 710, the computing machine 604 provides an output (or multipleoutputs) associated with the prediction 606. The output is associatedwith the future action or the future outcome in the prediction 606. Theoutput may be transmitted to a local display unit, speaker or printer,or transmitted over a network for further processing at a remotemachine.

In some implementations, the method 700 is performed using amultithreaded GPU (or other multithreaded processing circuitry) of thecomputing machine 604 (which may be a server farm that includes multiplecomputers). The multiple threads may be used to receive differentobservations (e.g., associated with different actors) and identify planscorresponding to the different observations in real-time and inparallel. In some cases, identification of a single plan may involvemultiple threads. For example, different threads may be used to comparea set of observations with different sets of actions 610A, 610B, 610Cwhich may correspond to plan prefixes stored in the data repository 608.

According to some implementations, the plan prefix is associated with afirst plan. The computing machine 604 identifies a second plan prefixassociated with the plurality of observations 602. The second planprefix is associated with a second plan. The computing machine 604determines that a conflict exists between the first plan and the secondplan, for example, due to both plans requiring a common item (e.g.,spouses who share a single car plan to drive to different places at thesame time). The computing machine 604 identifies a proposed resolutionfor the conflict (e.g., one of the spouses using a different mode oftransportation). The computing machine 604 provides an output indicatingthe conflict and the proposed resolution. The computing machine 604 mayuse the observations 602 and the data structures representing actions610A, 610B, 610C in the data repository 608 that were used to identifythe plan prefix associated with the first plan and the second planprefix associated with the second plan to project a final state of theworld and determine if the first plan and/or the second plan would beable to be executed to completion. If the first plan and/or the secondplan would not be able to be executed to completion, there is a conflictand a resolution may be proposed.

In one example, the computing machine 604 observes (in the observations602) a chef making two different salads, one is leafy greens and one isa cold pasta for a formal dinner. The computing machine 604 observes,via the observations 602, multiple steps of both plans (the plan to makethe leafy greens salad and the plan to make the cold pasta salad) and isvery confident of its recognition of the goals of each of the plans.However, the computing machine 604 has access to data indicating thatthere is only one bowl for serving salads on the table. As the computingmachine 604 becomes more and more confident of the goals and plans thecomputing machine 604 also becomes more confident that the chef intendsthat both salads are to be ready at the same time and served at the sametime. However, this is a problem because only one of the salads can usethe serving bowl at a time. Thus, the computing machine 604 is unable tocreate, in its memory, a state where both salads are served at the sametime. As a result, a conflict is identified. To find a resolution topropose, the computing machine 604 accesses data structures that allowit to use its planning algorithm to infer that if the chef is willing toserve the salads in series, and that the chef can wash the bowl betweenthe two courses. Thus, the computing machine 604 provides an outputindicating that both salads cannot be served simultaneously because onlyone bowl is available, and an output indicating a recommendation toserve the salads in series and to wash the bowl between the two saladcourses.

According to some implementations, the prediction 606 indicates afailure of a plan associated with the plan prefix. The computing machine604 identifies a proposed resolution that allows for success of theplan. For example, by accessing observed states of the world andallowing the planner engine of the computing machine 604 to project thestate of the world forward, the computing machine 604 may identify plansthat will fail and even alternative plans that will succeed and whatcould be changed so that the original plan would succeed. The computingmachine 604 provides an output indicating the proposed resolution (e.g.,an alternative plan or a change to the original plan that would causethe original plan to succeed). The computing machine 604 may determine,among other things, that an item (e.g., from a stored inventory ofitems, which may be stored at the computing machine 604, at the datarepository 608, or at one or more other machines accessible to thecomputing machine 604, e.g., via a network) associated with a plan ismissing or being used for another plan that is already beingimplemented, or that the plan cannot be completed for another reason(e.g., based on physics data, traffic data, or capability data). Forexample, if a plan requires a person named Betsy to be at ABC CoffeeHouse in 30 minutes but, due to traffic, Betsy requires 60 minutes todrive to ABC Coffee House, the computing machine may determine thatBetsy’s plan is going to fail.

A resolution may be determined based on the nature of the plan. Forexample, if Betsy’s plan is to drink a cup of coffee alone (e.g., basedon an indication Betsy provided to the computing machine 604 or based onstored calendar data of Betsy), the computing machine 604 may recommendthat Betsy make her own coffee at home. If Betsy is meeting a colleague(e.g., based on a calendar event in Betsy’s calendar or a calendarinvite or email that Betsy sent or received that is stored at thecomputing machine 604) at ABC Coffee House, the computing machine 604may recommend that Betsy reschedule the meeting or move the meeting to adifferent location. In some implementations and with appropriatepermissions from Betsy’s colleague, the computing machine may access atracked (e.g., via a mobile device associated with Betsy’s colleague)location of Betsy’s colleague. If both Betsy and her colleague arelikely to be late to the meeting at ABC Coffee House, the computingmachine may notify Betsy that both she and her colleague are runninglate, and propose delaying or rescheduling the meeting (or changing alocation of the meeting, for instance, to a coffee shop that is closerthan ABC Coffee House). In some cases, the computing machine may,automatically or in response to a request from Betsy, automaticallycompose a written, audio or video message for transmission to an address(e.g., an email address, a telephone number, or an address in an instantmessaging service) associated with Betsy’s colleague proposing delaying,rescheduling, and/or changing a location of the meeting.

In one example, the computing machine 604 observes (via the observations602) a chef making a salad for a formal dinner. However, the computingmachine 604 determines, based on data accessible to the computingmachine 604 (e.g., an electronic inventory of items in the kitchen,which may be persistently monitored, for example, using sensor(s) in thekitchen), that there are no bowls that are appropriate for placing thesalad on the table. The computing machine 604 identifies a plan forcompleting making the salad and serving the salad, but determines thatthe serving of the salad in the formal dinner environment is notpossible due to the lack of a bowl. To propose a resolution, thecomputing machine 604 may determine that the dinner may be made lessformal. The salad may then be served in the container used for thepreparation of the salad. The computing machine 604 may determine thatthe serving of the salad in the container used for the preparation ofthe salad is similar to the original proposal of serving the salad inthe (nonexistent) formal bowl.

FIG. 8 illustrates example data structures 800 which may be used forplan recognition, in accordance with some embodiments. As shown, thedata structures 800 include an input data structure 802 withobservations 804A, 804B, and a data structure representing actions 806in a plan. The observations 804A, 804B may correspond to theobservations 602 of FIG. 6 . The data structure representing actions 806may correspond to one of the data structures 610A, 610B, 610C in thedata repository 608.

As shown, the data structure representing actions 806 in a plan isassociated with a plan to take an object. The data structurerepresenting actions 806 has a tree structure with the root node 808representing the “take” plan. The tree structure also has three leafnodes 810, 812, 814 representing individual actions in the “take” plan -“reach” 810, “grasp” 812, and “lift” 814.

As illustrated, observation 804A is mapped to the “reach” leaf node 810and observation 804B is mapped to the “grasp” leaf node 812. Thismapping may be based on using artificial intelligence or machinelearning techniques (e.g., as described in conjunction with FIGS. 1-4 )to identify that imagery (or other data) in the observation 804Acorresponds to reaching and that imagery (or other data) in theobservation 804B correspond to grasping. Based on this mapping, acomputing machine (e.g., the computing machine 604) may determine that a“take” plan is being implemented because “reach” (per leaf node 810) and“grasp” (per leaf node 812) have been completed. The computing machinemay make a prediction that “lift” (per leaf node 814) is likely to beattempted.

The computing machine may make a prediction about whether the “lift” isto be successful. In one example, an object is being taken by a workerwho is capable of lifting a maximum of 50-70 kg. (Informationrepresenting the worker’s capabilities and/or the mass of the object maybe stored at the computing machine or at a data repository to which thecomputing machine is connected.) If the object has a mass of 45 kg, thecomputing machine may predict that the “lift” is to be successful.

However, if the object has a mass of 90 kg, the “lift” is likely tofail. In this case, the computing machine may propose (e.g., via itsoutput) various remediations to allow the “lift” to succeed. Forexample, the computing machine may propose that a stronger worker liftthe object instead of the worker who is capable of lifting the maximumof 50-70 kg or the computing machine may propose that a second worker ora machine assist the worker who is capable of lifting the maximum of50-70 kg with the “lift.”

In some cases, the computing machine may identify that two ongoing plansconflict with one another. For example, at 18:15 on a Friday evening,the computing machine may determine that a patent attorney has a plan to“take wife to dinner” at 19:00 (with the dinner requiring two hours oftime for travel and dining) and a plan to “finish and file patentapplication” by 23:59 (with the patent application requiring 5.5 hoursof labor). The “take wife to dinner” plan may be identified based on adinner reservation made by the patent attorney. The “finish and filepatent application” plan may be identified based on the patent attorneycommunicating with the client (e.g., based on an artificial intelligenceanalysis (e.g., as described in conjunction with FIGS. 1-4 ) of text inthe communications between the patent attorney and the client indicatingthat the patent application must be filed by 23:59 that evening) andbeginning the drafting of the patent application.

In this case, the computing machine may generate output indicating thatthe two plans conflict with one another. The computing machine mayoutput one or more proposed remediations, for example, “rescheduledinner with wife,” or “reassign patent application to associate.” Afterreceiving an appropriate response from the user, the computing machinemay automate the rescheduling of the dinner (e.g., by automaticallymodifying a reservation or automatically telephoning the restaurant andhaving a receptionist at the restaurant hear a recording indicating therescheduling request or by automatically sending an email to theassociate indicating the reassignment of the patent application).

The disclosed technology may be useful in various domains. For example,in computer cyber security, the disclosed technology may be leveraged insecurity system configuration tools and in recognizing the plans ofhostile actors. Actions of various actors in a network system may beobserved and a prediction may be made that a certain actor is makinghostile actions based on the actions of the actor. For example, if aplan for a hostile act includes steps A, B, C, D, and E, an actor thatperforms steps A and B may be predicted to be preforming the hostileact.

In control systems for manufacturing, the disclosed technology may beused in graphical user interfaces (GUIs) for control or manufacturingsystems, oil refineries, chemical or other manufacturing. An engineassociated with the GUI may detect steps being performed by an operatorand may predict the operator’s likely next steps. User interfaceelements for performing these next steps may be presented via the GUI.

The disclosed technology may be used in control systems for transportscheduling and logistics, by identifying plans associated with transportneeds or desires. In addition, conflicts between transportation plans(e.g., two drivers plan to drive the same truck) may be detected andresolved. The disclosed technology may be used in assistive systems forelderly people, for example, in “smart” at home monitoring for elderlypeople to assist them with activities of daily living (ADLs). A usersactions may be observed to identify an ADL that the user is attemptingas well as a likelihood that the user will succeed. If the likelihood isbelow a threshold (e.g., 50%), remediations to increase the likelihoodof success (or decrease the likelihood of injury) may be suggested.

The disclosed technology may be useful in spoken or naturallanguage-based interfaces, for example, automated call centers, personaldigital assistants, self-driving cars, household appliances, and chatbots. The disclosed technology may be useful in spoken, textual, orGUI-based intelligent personal assistant systems. A personal digitalassistant may receive input from a user and suggest next steps. Forexample, a plan to book travel may include the steps: (1) book flight,(2) book hotel, and (3) book rental car. If a user books a flight usingthe personal digital assistant, the personal digital assistant maysuggest also booking a hotel and/or a rental car.

The disclosed technology may be useful in a computer system designed toassist users with a task or configuration process, which may be spoken,textual, or GUI-based. For example, the disclosed technology may detecta user’s intentions for a software system while the software system isbeing configured. Steps in the configuration process may be configuredbased on the intentions. For example, a user using tax software to filesimple personal returns may need a different tax software installationfrom a user who is using the tax software to file more complex returnsfor corporations or high-net-worth individuals.

The disclosed technology may be useful in video games which may havebelievable non-player characters with which human player(s) mayinteract. The non-player character may access an engine that predictsfuture actions of the human player(s) based on their previous actions,as described herein. The domains described herein are provided asexamples only and do not limit the disclosed technology.

In one example, the disclosed technology may be useful in a deliverysystem. The technology may identify delivery plans, for example, basedon activities of delivery drivers. The disclosed technology maydetermine when certain delivery plans are likely to fail and/or whethercertain delivery plans conflict with one another, and may provideremediation steps to reduce the failure rate. The remediation steps maybe provided to a device of a manager of the delivery system (or amessaging address associated with the manager), for example, via pushnotification, online chat application, short messaging service (SMS), oremail.

In one example, the disclosed technology is useful in assisting anelderly person with ADLs. A computing machine may observe (e.g., usingat least one of a camera, a microphone, a radar system, a lidar system,or the like) activities of the elderly person, identify plan(s) of theelderly person based on the observed activities, determine whether theidentified plan(s) are likely to succeed or fail, and/or suggestremediation steps for plan(s) that are likely to fail. The suggestedremediation steps may be provided using an audio or visual output of thecomputing machine.

FIG. 9 is a block diagram of an example of a plan recognition system900, in accordance with some embodiments. The plan recognition system900 may be implemented in software, hardware, or a combination ofsoftware and hardware residing at one or more computing machines (e.g.,the computing machine 500). As shown, the system 900 stores observations902, which include actions 904 and states 906. The actions 904 may beassociated with an agent (e.g., a human) or the environment (e.g.,weather actions) and may involve activity of the user or theenvironment. The states 906, similarly, may be associated with an agent(e.g., a person named Jack is in his car and driving east on MainStreet) or the environment (e.g., the bridge over the river at the eastend of Main Street is closed to vehicular traffic). The observations 902may be obtained via sensors (e.g., a camera, a microphone, a temperaturesensor, a pressure sensor, or the like) from an environment.Alternatively, the observations 902 may be manually entered into the oneor more computing machines or may be obtained via application of machinelearning techniques (e.g., natural language processing) to one or moredata sources (e.g., online newspaper articles, social media posts, orthe like).

As shown, the observations 902 are provided to a plan recognizer engine908. The plan recognizer engine 908 generates an observation datastructure 910. The observation data structure 910 represents causalstructures 912 and hierarchical relationships 914 based on the states904 and the actions 906 in the observations 902. According to someexamples, the observation data structure 910 is a graph data structureincluding nodes and edges connecting the nodes. The nodes represent thestates 906 and the actions 904. The edges represent the causalstructures 912 and/or the hierarchical relationships 914 between thenodes. The causal structures 912 may include at least one of a causalrelationship between two or more actions from the actions 904, a statechange associated with one or more actions from the actions 904, or asubplan of an agent performing at least a portion of the actions fromthe actions 904. The causal structures 912 may be sub-graph structuresthat capture the causal relationships between action nodes and predicatenodes that make up states and goals. For example, the action of openinga door with the left hand causes the door to be open, i.e., openA(lefthand, door23 ) --> openP( door23 ). The hierarchical relationships914 may include subgraph structures that capture the relationships andordering constraints between groups of action nodes. The action nodescapture the fact that when the actions are executed in an order thatmeets the ordering constraints, the actions can result in theaccomplishment of a known state of the world, plan, or other largersub-units of observation data structure. For example, the sequence ofactions graspA( lefthand, block2 ), liftA( lefthand ), moveoverA(lefthand, block3 ), releaseA( lefthand ) can all be linked under themore abstract action node of stackOnA( block2, block3 ) capturing a planfor stacking block2 on block3 (i.e., onP( block2, block3 ) ). Suchstructures can capture both the required substeps as well as those thatare optional, and even mutually exclusive alternative action sequencesfor the same abstract action.

In one innovative example, the system 900 resides within a computingmachine of a vehicle (e.g., an infotainment system or a vehicularcontrol system). The actions 904 and states 906 include actions observedby sensors at the vehicle and data obtained via the global positioningsystem (GPS) of the vehicle. The actions 904 and states 906 may alsoinclude data provided by a traffic service, a meteorological service,and/or calendar data of a user of the vehicle (e.g., if the user linkedtheir calendar to the computing machine of the vehicle). For example,the vehicle may determine, using the GPS, its position (in the sates906) at consecutive times to determine that the vehicle is driving (inthe actions 904) east on Main Street at a speed of 50 kilometers perhour. The vehicle may determine, based on a traffic service, that abridge over a river at the east end of Main Street is closed tovehicular traffic. The vehicle may also determine, based on an onlinecalendar of the user, that the user is likely driving to have lunch at arestaurant on the other side of the bridge from the vehicle’s currentlocation. The information about the bridge being closed may be stored inthe states 906. The information about the user driving to the restaurantmay be stored in the actions 904.

In this example, the plan recognizer engine 908 may determine, based onthe observations 902 from the online calendar and of the vehicle’s speedand direction, that the user of the vehicle is likely driving to therestaurant across the bridge. The causal structure 912 may be used toindicate that a plan to go to the restaurant would include driving easton Main Street and then going over the bridge. This plan is consistentwith the online calendar of the user.

As illustrated, a planner engine 916 accesses the observation datastructure 910. The planner engine 916 extends the observation datastructure 910, in accordance with the causal structures 912 and thehierarchical relationships 914, to include predicted states 918 and/orpredicted actions 920 that are not from the observations 902 whilemaintaining a format and a structure of the observation data structure910. The predicted states 918 and/or the predicted actions 920 areincorporated into the observation data structure 910, similarly to theactions 904 and/or the states 906 from the observations 902.

In the above example, the planner engine 916 may determine, based on theuser’s calendar and the current location, speed, and direction of thevehicle, that the user plans to drive the vehicle over the bridge to getto the restaurant on the other side of the river. This may lead to thecreation of a predicted action 920 of “driving over the bridge” and/or apredicted state 918 of “vehicle on the bridge.”

A consistency rule engine 922 enforces consistency rules 924 on theobservation data structure 910. The consistency rule engine 922 reducesthe observation data structure 910. To do so, the consistency ruleengine 922 determines whether a predicted state (from the predictedstates 918) or a predicted action (from the predicted actions 920) isconsistent with the observations 902 and the consistency rules 924. Theconsistency rule engine 922 maintains the predicted state or thepredicted action if the predicted state or the predicted action isconsistent with the observations 902 and the consistency rules 924. Theconsistency rule engine 922 removes the predicted state or the predictedaction if the predicted state or the predicted action is inconsistentwith the observations 902 and the consistency rules 924. The consistencyrules 924 may include any rules that are applied to the system fromwhich the observations 902 are generated. For example, the consistencyrules 924 may include rules of physics, rules of traffic, or the like.After the consistency rule engine 922 enforces the consistency rules924, the system 900 may generate an output based on the observation datastructure 910. A consistency rule from the consistency rules 924 may bea first order predicate or conjunction of first order predicates, suchthat for an explanation data structure it can be determined if thepredicate or conjunction holds. For example imagine two explanation datastructures for the observed sequence of actions: [graspA( lefthand,block2 ), liftA( lefthand ), moveoverA( lefthand, block3 ), releaseA(lefthand )]. One accounts for the observed actions as a plan to stackblock2 on block3. The other accounts for the same actions as a plan toclear what ever surface block2 was initially on. The consistency rulebased on testing if onP( block2, block3 ) is the goal of the plan can beused to differentiate these two explanation data structures. Anexplanation data structure may be a graph data structure that capturesone complete and consistent set of possibly multiple goals and plansthat are sufficient to account for the observed agent executing theactions in the input set. It should be noted that there may be a largenumber of such explanations. In our implementation each such datastructure places each observed action or state change in order, within astructure that captures details of the action, the causal relationsbetween the states in which the action is executed, and the stateresulting from its execution. Further, the data structure containsstructures that capture the organization of sets of the actions intolarger sub-plans and even whole plans that achieve goals.

In the above example with the bridge, the consistency rules 924 mayinclude a rule that vehicles cannot travel on roads that are closed tovehicular traffic. In this case, the consistency rule engine 922 maydetermine that the predicted action 920 of “driving over the bridge”and/or the predicted state 918 of “vehicle on the bridge” isinconsistent with the consistency rule 924 of the vehicle not travelingon roads that are closed to vehicular traffic. The computing machine maygenerate an output (e.g., that is played via a speaker of the vehicle’sinfotainment system) notifying the user that the bridge is closed. Theoutput may also include a display of a map of an alternate route to therestaurant and/or activation of a navigation system to assist withnavigation to the restaurant.

As further illustrated in FIG. 9 , the system 900 includes planstructures 926. The plan structures 926 include structures for multipledifferent plans. For example, a plan structure for “take object,” mayinclude the steps of “reach,” “grasp,” and “lift.” A plan structure for“book trip,” may include the steps of “book flight,” “book hotel,” and“book rental car.” Using the plan structures 926, the plan recognizerengine 908 maps the actions 904 and the states 906 in the observations902 to a fully or partially completed plan (e.g., a plan prefix). Usingthe plan structures 926, the planner engine 916 generates the predictedstates 918 and/or the predicted actions 920 for a partially completedplan represented in the observation data structure 920.

FIGS. 10A-10B illustrate examples of data representing a plan, inaccordance with some embodiments. FIG. 10A illustrates observed plandata 1000A which includes observed actions and observed states of arecognized plan structure. FIG. 10B illustrates plan data 1000B, whichincludes a combination of observed actions, predicted actions, observedstates of a recognized plan structure, and states components of therecognized plan structure.

As shown in FIG. 10A, the observed plan data 1000A includes observedactions 1002A. The observed actions 1002A may correspond to actions 904in the observations 902 shown in FIG. 9 . The observed actions 1002A aremapped onto states 1004A of a recognized plan structure. The states1004A may correspond to states 906 in the observations 902. For example,if the plan is to attend a wedding in Napa, California, the observedactions 1002A may correspond to booking a flight to San FranciscoAirport, confirming one’s attendance at the wedding, and booking a hotelroom. The observed states 1004A may correspond to the wedding not havingbeen cancelled or changed to a different venue, the airline confirmingthe booking of the flight, and the hotel operator confirming the bookingof the hotel room. In some cases, the plan recognizer engine 908identifies that the plan is to attend the wedding in Napa based on theconfirmation of attendance and the booking of the flight and hotel room.For example, the plan recognizer engine 908 maps the observed actions1002A and the observed states 1004A to a portion (e.g., corresponding toa plan prefix) of one of the plan structures 926. The plan recognizerengine 908 may, with the affirmative consent of the user, monitor atleast one of a computing device, an email address, a calendar, or acredit card of the user to identify the observed actions 1002A and/orthe observed states 1004A.

FIG. 10B illustrates plan data 1000B. As shown, the plan data 100Bincludes the observed actions 1002A and the states 1004A from theobserved plan data 1000A. In addition, the plan data 1000B includespredicted actions 1002B and predicted states 1004B. The predictedactions 1002B and/or the predicted states 1004B may be determined, byoperation of the planner engine 916, and based on the plan structurefrom the plan structures 926 that was recognized, as corresponding tothe observed actions 1002A and the observed states 1004A by the planrecognizer engine 908. The predicted states 1004B may include, forexample, that the user is attending the wedding while wearingappropriate attire (e.g., a suit or a dress). A corresponding predictedaction 1002B to these predicted states 1004B may include purchasing theappropriate attire and/or having the appropriate attire tailored. Thepredicted states 1004B may include traveling from San Francisco Airportto Napa by rental car. A corresponding predicted action 1002B mayinclude booking a rental car. The predicted states 1004B may includetraveling by taxi from one’s home to the departure airport. Acorresponding predicted action 1002B may include booking the taxi. Insome cases, some predicted states might not have a correspondingpredicted action.

According to some implementations, the predicted actions 1002B and/orthe predicted states 1004B correspond to the predicted actions 920and/or the predicted states 918 shown in FIG. 9 , respectively. Thepredicted actions 1002B and/or the predicted states 1004B may bedetermined using the planner engine 916. Furthermore, a computingmachine may generate an output based on the predicted actions 1002Band/or the predicted states. For example, a personal assistantapplication (e.g., on a mobile phone or a dedicated personal assistantdevice) might generate a suggestion for the user to obtain theappropriate attire, book the rental car, and/or book the taxi.

FIG. 11 is a flow chart of an example of a plan recognition method 1100,in accordance with some embodiments. As described below, the method 1100is performed by a computing machine (e.g., the computing machine 500 orthe system 900). However, in alternative implementations, the method1100 may be performed by other machines, for example, by a machineincluding all or a portion of the components of the computing machine500 or by multiple computing machines working together.

At block 1102, the computing machine receives a plurality ofobservations (e.g., the observations 902). The plurality of observationsinclude a set of actions (e.g., the actions 904) and a set of states(e.g., the states 906).

At block 1104, a plan recognizer engine (e.g., the plan recognizerengine 908) at the computing machine generates an observation datastructure (e.g., the observation data structure 910). The observationdata structure represents causal structures (e.g., the causal structures912) and hierarchical relationships (e.g., the hierarchicalrelationships 914) between states and actions in the plurality ofobservations. In some cases, the computing machine sorts the pluralityof observations into multiple groups, each group being associated with aplan or a plan prefix. In some cases, all or a portion of theobservations in the observation data structure may be mapped to a planprefix, representing initial steps towards the completion of a plan.

At block 1106, a planner engine (e.g., the planner engine 916) at thecomputing machine extends, in accordance with the causal structures andthe hierarchical relationships, the observation data structure toinclude predicted states (e.g., the predicted states 918) or predictedactions (e.g., the predicted actions 920) that are not from theplurality of observations while maintaining a format and a structure ofthe observation data structure. If a plan prefix is mapped to theobservation data structure, extending the observation data structure mayinclude adding, to the observation data structure, a predicted state inaccordance with a completion of a plan corresponding to the plan prefix.The predicted state is one of the predicted states generated at block1106. The predicted state may include a state corresponding to thecompletion of the plan.

In some implementations, the computing machine maps the plurality ofobservations received at block 1102 to one or multiple plans. Extendingthe observation data structure (at block 1106) includes adding, to theobservation data structure, a predicted state in accordance with the oneor more plans. The predicted state is one of the predicted statesgenerated at block 1106.

At block 1108, the computing machine reduces the extended observationdata structure in accordance with consistency rules (e.g., theconsistency rules 924) stored in a memory of the computing machine. Insome cases, the computing machine determines whether a predicted stateor a predicted action is consistent with the plurality of observationsand the consistency rules. The computing machine maintains the predictedstate or the predicted action if the predicted state or the predictedaction is consistent with the plurality of observations and theconsistency rules. The computing machine removes the predicted state orthe predicted action if the predicted state or the predicted action isinconsistent with the plurality of observations or the consistencyrules.

In some implementations, extending the observation data structure (atblock 1106) includes receiving indicia of additional actions taken by anagent associated with the set of actions. Reducing the extendedobservation data structure (at block 1108) includes verifying that theadditional actions are in accordance with the consistency rules andremoving at least one additional action that is not in accordance withthe consistency rules.

At block 1110, the computing machine provides an output associated withthe reduced observation data structure. The output may include a promptto take an action or refrain from taking an action based on the reducedobservation data structure. The output may be provided for display at adisplay unit or played via an audio speaker. Alternatively, the outputmay be transmitted (e.g., via a network) to another computing machine orto a messaging address.

In some examples, the output includes a belief, a goal, a plan or anintention of an agent associated with (e.g., performing) the actions orthe states. The computing machine determines the belief, the goal, theplan or the intention based on the causal structures or the hierarchicalrelationships in the reduced observation data structure. In someexamples, the output includes a predicted future state. The predictedfuture state may be determined based on the plan. As used herein, theterm “belief” may include, among other things, a first order predicateor conjunction of first order predicates that specifically capture thebeliefs of either the observed agent or another agent within theenvironment. In some implementations, this is captured by adding anadditional parameter to the predicate that identifies which agent holdthe belief (i.e., inRoomP( agent23, block7, room23 ) captures the factthat agent 23 believes that block7 is in room23. In contrast inRoomP(block7, room23 ) captures the fact that in represented world block7 isin room23. Some implementations support the presence of typed variablesin the belief specification. For example, inRoomP( agent23, block7,X:room ) may denote that agent23 believes that block7 is in some roomthat will likely be bound at a later time in the plan.

In some examples, the plan recognizer engine and the planner engineoperate using multithreaded processing circuitry. The plan recognizerengine and the planner engine may each individually be parallelized,with the planner engine leveraging the output of the plan recognizerengine. The multithreaded processing circuitry, using theparallelization of the plan recognizer engine and the planner engine,generates the output in real-time after receiving the plurality ofobservations. Alternatively, in some implementations, parallelizationmight not be used, and the processing circuitry might still generate theoutput in real-time after receiving the plurality of observations. As aresult, a user is able to take action based on the output before theplan is completed or abandoned, and the output becomes irrelevant to theuser. For example, if a user begins baking a cake (e.g., by mixing theingredients for the cake), the technique disclosed herein may be used todetermine that the user has begun baking a cake and determine that theuser will not be able to complete baking the cake because the user’sspouse is using the oven to cook a meatloaf and only one oven isavailable. The user may be notified (e.g., by a push notification to amobile phone or by audio playback at an in-home personal assistantdevice) that they will not be able to complete baking the cake becausethe oven is being used for another project. As a result, the user mightabandon the cake baking project before too many of the ingredients havebeen mixed. Also, the user may have time to obtain a cake using anotherscheme (e.g., by driving to a bakery to buy a cake).

Some implementations of the disclosed technology may leverage artificialneural networks or machine learning. Alternatively, the disclosedtechnology may be implemented without artificial neural networktechnology and without machine learning technology. Some implementationsobtain input observations and build the explanation structures from theinput observations. This can be accomplished without artificial neuralnetworks and without machine learning.

Some implementations use computational technology to leverage thecomplexity of the resulting observation data structures. The initialobservation data structure can have multiple explanation data structureswithin itself.

Each such explanation data structure places each observed action orstate change in order, within a structure that captures details of theaction. The causal relations between the statistics in which each actionis executed and the results of executing each action. Furthermore, theobservation data structure contains more abstract structures thatcapture the organization of sets of the actions into larger sub-plansand even whole plans that achieve goals. The size of the resultingstructures depends on the number of observed actions.

In some implementations, each explanation structure is a graph with thefollowing form. If the number of observations is n, each explanationstructure has n action observation nodes. It also has n+1 world statenodes (capturing the state before and after the execution of eachaction). Each action node has a minimum of two edges between it and itsprevious and consequent states for a total of 2(n)+1 edges.

In some implementations for the simplest case, the explanation structurealso has nlog_{2}(n) nodes capturing the structure of the plan beingfollowed. Thus, the graph capturing an explanation data structure has atthe minimum 2nlog_{2}(n)+ 1 action and state nodes and 2nlog_{2}(n)links. It should be noted that this does not account for any complexityin the representation of the world states which should be taken intoaccount. The representation of the world states may, in some cases, betreated as a multiplicative constant on these figures. Thus, the size ofan individual explanation data structure graph depends polynomially onthe number of input observations.

It should be noted that the above analysis only accounts for a singleexplanation. The initial observation structure computed by the planrecognition engine may contain multiple such explanations. Some inputobservation sequences given to a plan recognition engine may involve theproduction of an exponentiation number of such explanation datastructure graphs.

In summary then, the first step of an example process disclosed hereinproduces an initial observation data structure that contains anexponential number of individual explanation data structures (the sizeof each of which is polynomial in the number of observations).

The second step of an example of the process may involve for extendingeach of these explanation graphs using the planner engine. Thisextension calls for the creation of multiple instances of each inputexplanation data structure. Each possible choice in how the plan may becontinued in the future is represented by its own instance of theexplanation data structure.

Thus, this extension process can result in multiplying the number ofexplanation data structure graphs by the number of possible alternativesto each possible choice for how each plan in the explanation could becompleted. Searching this space of possible completions of eachexplanation data structure using a planning engine may be in the mostcomputationally complex class and if a complete search is used for thedomain, it may leverage the production of an unbounded number ofexplanation data structures. Thus, the plan recognition engine and theplanning engine both create and extend a data structure that is morethan exponentially linked in size to the number of observations.

Some embodiments are described as numbered examples (Example 1, 2, 3,etc.). These are provided as examples only and do not limit thetechnology disclosed herein.

Example 1 is a method comprising: receiving, by a computing machine, aplurality of observations, the plurality of observations including a setof actions and a set of states; generating, by a plan recognizer engineat the computing machine, an observation data structure, wherein theobservation data structure represents causal structures and hierarchicalrelationships between states and actions in the plurality ofobservations; extending, by a planner engine at the computing machineand in accordance with the causal structures and hierarchicalrelationships, the observation data structure to include, predictedstates or predicted actions that are not from the plurality ofobservations while maintaining a format and a structure of theobservation data structure; reducing, in accordance with consistencyrules stored in a memory of the computing machine, the extendedobservation data structure by: determining whether a predicted state ora predicted action is consistent with the plurality of observations andthe consistency rules; maintaining the predicted state or the predictedaction if the predicted state or the predicted action is consistent withthe plurality of observations and the consistency rules; and removingthe predicted state or the predicted action if the predicted state orthe predicted action is inconsistent with the plurality of observationsor the consistency rules; and providing an output associated with thereduced observation data structure.

In Example 2, the subject matter of Example 1 includes, wherein the planrecognizer engine and the planner engine operate in parallel usingmultithreaded processing circuitry, and wherein the multithreadedprocessing circuitry generates the output in real-time after receivingthe plurality of observations.

In Example 3, the subject matter of Examples 1-2 includes, wherein theobservation data structure comprises a graph data structure includingnodes and edges connecting the nodes, wherein the nodes represent thestates and the actions, and wherein the edges represent the causalstructures or the hierarchical relationships between the nodes.

In Example 4, the subject matter of Examples 1-3 includes, the outputcomprising at least one of a belief, a goal, a plan, or an intention ofan agent associated with the actions or the states, the methodcomprising: determining the at least one of the belief, the goal, theplan, or the intention based on the causal structures of thehierarchical relationships in the reduced observation data structure.

In Example 5, the subject matter of Examples 1-4 includes, the outputcomprising a predicted future state.

In Example 6, the subject matter of Examples 1-5 includes, the causalstructures comprising at least one of a causal relationship between twoor more actions from the set of actions, a state change associated withone or more actions from the set of actions, or a subplan of an agentperforming at least a portion of the actions from the set of actions.

In Example 7, the subject matter of Examples 1-6 includes, mapping theplurality of observations to an execution of a plan prefix.

In Example 8, the subject matter of Example 7 includes, whereinextending the observation data structure comprises: adding, to theobservation data structure, a predicted state in accordance with acompletion of a plan corresponding to the plan prefix, wherein thepredicted state is one of the predicted states.

In Example 9, the subject matter of Example 8 includes, wherein thepredicted states include a state corresponding to the completion of theplan.

In Example 10, the subject matter of Examples 1-9 includes, mapping theplurality of observations to an execution of one or more plans, whereinextending the observation data structure comprises: adding, to theobservation data structure, a predicted state in accordance with the oneor more plans, wherein the predicted state is one of the predictedstates.

In Example 11, the subject matter of Examples 1-10 includes, sorting theplurality of observations into multiple groups, each group beingassociated with a plan or a plan prefix.

In Example 12, the subject matter of Examples 1-11 includes, whereinextending the observation data structure comprises: receiving indicia ofadditional actions taken by an agent associated with the set of actions,and wherein reducing the extended observation data structure comprises:verifying that the additional actions are in accordance with theconsistency rules and removing at least one additional action that isnot in accordance with the consistency rules.

Example 13 is a machine-readable medium storing instructions which, whenexecuted by a computing machine, cause the computing machine to performoperations comprising: receiving, by a computing machine, a plurality ofobservations, the plurality of observations including a set of actionsand a set of states; generating, by a plan recognizer engine at thecomputing machine, an observation data structure, wherein theobservation data structure represents causal structures and hierarchicalrelationships between states and actions in the plurality ofobservations; extending, by a planner engine at the computing machineand in accordance with the causal structures and hierarchicalrelationships, the observation data structure to include, predictedstates or predicted actions that are not from the plurality ofobservations while maintaining a format and a structure of theobservation data structure; reducing, in accordance with consistencyrules stored in a memory of the computing machine, the extendedobservation data structure by: determining whether a predicted state ora predicted action is consistent with the plurality of observations orthe consistency rules; maintaining the predicted state or the predictedaction if the predicted state or the predicted action is consistent withthe plurality of observations and the consistency rules; and removingthe predicted state or the predicted action if the predicted state orthe predicted action is inconsistent with the plurality of observationsand the consistency rules; and providing an output associated with thereduced observation data structure.

In Example 14, the subject matter of Example 13 includes, wherein theplan recognizer engine and the planner engine operate in parallel usingmultithreaded processing circuitry, and wherein the multithreadedprocessing circuitry generates the output in real-time after receivingthe plurality of observations.

In Example 15, the subject matter of Examples 13-14 includes, whereinthe observation data structure comprises a graph data structureincluding nodes and edges connecting the nodes, wherein the nodesrepresent the states and the actions, and wherein the edges representthe causal structures or the hierarchical relationships between thenodes.

In Example 16, the subject matter of Examples 13-15 includes, the outputcomprising at least one of a belief, a goal, a plan, or an intention ofan agent associated with the actions or the states, the methodcomprising: determining the at least one of the belief, the goal, theplan, or the intention based on the causal structures of thehierarchical relationships in the reduced observation data structure.

Example 17 is a system comprising: processing circuitry; and a memorystoring instructions which, when executed by the processing circuity,cause the processing circuitry to perform operations comprising:receiving, by a computing machine, a plurality of observations, theplurality of observations including a set of actions and a set ofstates; generating, by a plan recognizer engine at the computingmachine, an observation data structure, wherein the observation datastructure represents causal structures and hierarchical relationshipsbetween states and actions in the plurality of observations; extending,by a planner engine at the computing machine and in accordance with thecausal structures and hierarchical relationships, the observation datastructure to include, predicted states or predicted actions that are notfrom the plurality of observations while maintaining a format and astructure of the observation data structure; reducing, in accordancewith consistency rules stored in a memory of the computing machine, theextended observation data structure by: determining whether a predictedstate or a predicted action is consistent with the plurality ofobservations and the consistency rules; maintaining the predicted stateor the predicted action if the predicted state or the predicted actionis consistent with the plurality of observations and the consistencyrules; and removing the predicted state or the predicted action if thepredicted state or the predicted action is inconsistent with theplurality of observations or the consistency rules; and providing anoutput associated with the reduced observation data structure.

In Example 18, the subject matter of Example 17 includes, wherein theplan recognizer engine and the planner engine operate in parallel usingmultithreaded processing circuitry, and wherein the multithreadedprocessing circuitry generates the output in real-time after receivingthe plurality of observations.

In Example 19, the subject matter of Examples 17-18 includes, whereinthe observation data structure comprises a graph data structureincluding nodes and edges connecting the nodes, wherein the nodesrepresent the states and the actions, and wherein the edges representthe causal structures or the hierarchical relationships between thenodes.

In Example 20, the subject matter of Examples 17-19 includes, the outputcomprising at least one of a belief, a goal, a plan, or an intention ofan agent associated with the actions or the states, the methodcomprising: determining the at least one of the belief, the goal, theplan, or the intention based on the causal structures of thehierarchical relationships in the reduced observation data structure.

Example 21 is at least one machine-readable medium includinginstructions that, when executed by processing circuitry, cause theprocessing circuitry to perform operations to implement of any ofExamples 1-20.

Example 22 is an apparatus comprising means to implement of any ofExamples 1-20.

Example 23 is a system comprising processing circuitry and memory, theprocessing circuitry to implement of any of Examples 1-20.

Example 24 is a method to implement of any of Examples 1-20.

Although an embodiment has been described with reference to specificexample embodiments, it will be evident that various modifications andchanges may be made to these embodiments without departing from thebroader spirit and scope of the present disclosure. Accordingly, thespecification and drawings are to be regarded in an illustrative ratherthan a restrictive sense. The accompanying drawings that form a parthereof show, by way of illustration, and not of limitation, specificembodiments in which the subject matter may be practiced. Theembodiments illustrated are described in sufficient detail to enablethose skilled in the art to practice the teachings disclosed herein.Other embodiments may be utilized and derived therefrom, such thatstructural and logical substitutions and changes may be made withoutdeparting from the scope of this disclosure. This Detailed Description,therefore, is not to be taken in a limiting sense, and the scope ofvarious embodiments is defined only by the appended claims, along withthe full range of equivalents to which such claims are entitled.

Although specific embodiments have been illustrated and describedherein, it should be appreciated that any arrangement calculated toachieve the same purpose may be substituted for the specific embodimentsshown. This disclosure is intended to cover any and all adaptations orvariations of various embodiments. Combinations of the aboveembodiments, and other embodiments not specifically described herein,will be apparent to those of skill in the art upon reviewing the abovedescription.

In this document, the terms “a” or “an” are used, as is common in patentdocuments, to include one or more than one, independent of any otherinstances or usages of “at least one” or “one or more.” In thisdocument, the term “or” is used to refer to a nonexclusive or, such that“A or B” includes “A but not B,” “B but not A,” and “A and B,” unlessotherwise indicated. In this document, the terms “including” and “inwhich” are used as the plain-English equivalents of the respective terms“comprising” and “wherein.” Also, in the following claims, the terms“including” and “comprising” are open-ended, that is, a system, userequipment (UE), article, composition, formulation, or process thatincludes elements in addition to those listed after such a term in aclaim are still deemed to fall within the scope of that claim. Moreover,in the following claims, the terms “first,” “second,” and “third,” etc.are used merely as labels, and are not intended to impose numericalrequirements on their objects.

The Abstract of the Disclosure is provided to comply with 37 C.F.R.§1.72(b), requiring an abstract that will allow the reader to quicklyascertain the nature of the technical disclosure. It is submitted withthe understanding that it will not be used to interpret or limit thescope or meaning of the claims. In addition, in the foregoing DetailedDescription, it can be seen that various features are grouped togetherin a single embodiment for the purpose of streamlining the disclosure.This method of disclosure is not to be interpreted as reflecting anintention that the claimed embodiments require more features than areexpressly recited in each claim. Rather, as the following claimsreflect, inventive subject matter lies in less than all features of asingle disclosed embodiment. Thus the following claims are herebyincorporated into the Detailed Description, with each claim standing onits own as a separate embodiment.

What is claimed is:
 1. A method comprising: receiving, by a computingmachine, a plurality of observations, the plurality of observationsincluding a set of actions and a set of states; generating, by a planrecognizer engine at the computing machine, an observation datastructure, wherein the observation data structure represents causalstructures and hierarchical relationships between states and actions inthe plurality of observations; extending, by a planner engine at thecomputing machine and in accordance with the causal structures andhierarchical relationships, the observation data structure to includepredicted states or predicted actions that are not from the plurality ofobservations while maintaining a format and a structure of theobservation data structure; reducing, in accordance with consistencyrules stored in a memory of the computing machine, the extendedobservation data structure by: determining whether a predicted state ora predicted action is consistent with the plurality of observations andthe consistency rules; maintaining the predicted state or the predictedaction if the predicted state or the predicted action is consistent withthe plurality of observations and the consistency rules; and removingthe predicted state or the predicted action if the predicted state orthe predicted action is inconsistent with the plurality of observationsor the consistency rules; and providing an output associated with thereduced observation data structure.
 2. The method of claim 1, whereinthe plan recognizer engine and the planner engine operate in parallelusing multithreaded processing circuitry, and wherein the multithreadedprocessing circuitry generates the output in real-time after receivingthe plurality of observations.
 3. The method of claim 1, wherein theobservation data structure comprises a graph data structure includingnodes and edges connecting the nodes, wherein the nodes represent thestates and the actions, and wherein the edges represent the causalstructures or the hierarchical relationships between the nodes.
 4. Themethod of claim 1, the output comprising at least one of a belief, agoal, a plan, or an intention of an agent associated with the actions orthe states, the method comprising: determining the at least one of thebelief, the goal, the plan, or the intention based on the causalstructures of the hierarchical relationships in the reduced observationdata structure.
 5. The method of claim 1, the output comprising apredicted future state.
 6. The method of claim 1, the causal structurescomprising at least one of a causal relationship between two or moreactions from the set of actions, a state change associated with one ormore actions from the set of actions, or a subplan of an agentperforming at least a portion of the actions from the set of actions. 7.The method of claim 1, further comprising: mapping the plurality ofobservations to an execution of a plan prefix.
 8. The method of claim 7,wherein extending the observation data structure comprises: adding, tothe observation data structure, a predicted state in accordance with acompletion of a plan corresponding to the plan prefix, wherein thepredicted state is one of the predicted states.
 9. The method of claim8, wherein the predicted states include a state corresponding to thecompletion of the plan.
 10. The method of claim 1, further comprising:mapping the plurality of observations to an execution of one or moreplans, wherein extending the observation data structure comprises:adding, to the observation data structure, a predicted state inaccordance with the one or more plans, wherein the predicted state isone of the predicted states.
 11. The method of claim 1, furthercomprising: sorting the plurality of observations into multiple groups,each group being associated with a plan or a plan prefix.
 12. The methodof claim 1, wherein extending the observation data structure comprises:receiving indicia of additional actions taken by an agent associatedwith the set of actions, and wherein reducing the extended observationdata structure comprises: verifying that the additional actions are inaccordance with the consistency rules and removing at least oneadditional action that is not in accordance with the consistency rules.13. A non-transitory machine-readable medium storing instructions which,when executed by a computing machine, cause the computing machine toperform operations comprising: receiving, by a computing machine, aplurality of observations, the plurality of observations including a setof actions and a set of states; generating, by a plan recognizer engineat the computing machine, an observation data structure, wherein theobservation data structure represents causal structures and hierarchicalrelationships between states and actions in the plurality ofobservations; extending, by a planner engine at the computing machineand in accordance with the causal structures and hierarchicalrelationships, the observation data structure to include predictedstates or predicted actions that are not from the plurality ofobservations while maintaining a format and a structure of theobservation data structure; reducing, in accordance with consistencyrules stored in a memory of the computing machine, the extendedobservation data structure by: determining whether a predicted state ora predicted action is consistent with the plurality of observations orthe consistency rules; maintaining the predicted state or the predictedaction if the predicted state or the predicted action is consistent withthe plurality of observations and the consistency rules; and removingthe predicted state or the predicted action if the predicted state orthe predicted action is inconsistent with the plurality of observationsand the consistency rules; and providing an output associated with thereduced observation data structure.
 14. The machine-readable medium ofclaim 13, wherein the plan recognizer engine and the planner engineoperate in parallel using multithreaded processing circuitry, andwherein the multithreaded processing circuitry generates the output inreal-time after receiving the plurality of observations.
 15. Themachine-readable medium of claim 13, wherein the observation datastructure comprises a graph data structure including nodes and edgesconnecting the nodes, wherein the nodes represent the states and theactions, and wherein the edges represent the causal structures or thehierarchical relationships between the nodes.
 16. The machine-readablemedium of claim 13, the output comprising at least one of a belief, agoal, a plan, or an intention of an agent associated with the actions orthe states, the method comprising: determining the at least one of thebelief, the goal, the plan, or the intention based on the causalstructures of the hierarchical relationships in the reduced observationdata structure.
 17. A system comprising: processing circuitry; and amemory storing instructions which, when executed by the processingcircuity, cause the processing circuitry to perform operationscomprising: receiving, by a computing machine, a plurality ofobservations, the plurality of observations including a set of actionsand a set of states; generating, by a plan recognizer engine at thecomputing machine, an observation data structure, wherein theobservation data structure represents causal structures and hierarchicalrelationships between states and actions in the plurality ofobservations; extending, by a planner engine at the computing machineand in accordance with the causal structures and hierarchicalrelationships, the observation data structure to include predictedstates or predicted actions that are not from the plurality ofobservations while maintaining a format and a structure of theobservation data structure; reducing, in accordance with consistencyrules stored in a memory of the computing machine, the extendedobservation data structure by: determining whether a predicted state ora predicted action is consistent with the plurality of observations andthe consistency rules; maintaining the predicted state or the predictedaction if the predicted state or the predicted action is consistent withthe plurality of observations and the consistency rules; and removingthe predicted state or the predicted action if the predicted state orthe predicted action is inconsistent with the plurality of observationsor the consistency rules; and providing an output associated with thereduced observation data structure.
 18. The system of claim 17, whereinthe plan recognizer engine and the planner engine operate in parallelusing multithreaded processing circuitry, and wherein the multithreadedprocessing circuitry generates the output in real-time after receivingthe plurality of observations.
 19. The system of claim 17, wherein theobservation data structure comprises a graph data structure includingnodes and edges connecting the nodes, wherein the nodes represent thestates and the actions, and wherein the edges represent the causalstructures or the hierarchical relationships between the nodes.
 20. Thesystem of claim 17, the output comprising at least one of a belief, agoal, a plan, or an intention of an agent associated with the actions orthe states, the method comprising: determining the at least one of thebelief, the goal, the plan, or the intention based on the causalstructures of the hierarchical relationships in the reduced observationdata structure.